KILLED proof of input_tPG2njOyMv.trs # AProVE Commit ID: aff8ecad908e01718a4c36e68d2e55d5e0f16e15 fuhs 20220216 unpublished The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF). (0) CpxTRS (1) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms] (2) CpxTRS (3) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms] (4) CpxTRS (5) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms] (6) CpxWeightedTrs (7) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms] (8) CpxTypedWeightedTrs (9) CompletionProof [UPPER BOUND(ID), 0 ms] (10) CpxTypedWeightedCompleteTrs (11) NarrowingProof [BOTH BOUNDS(ID, ID), 522 ms] (12) CpxTypedWeightedCompleteTrs (13) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms] (14) CpxRNTS (15) InliningProof [UPPER BOUND(ID), 1527 ms] (16) CpxRNTS (17) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms] (18) CpxRNTS (19) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms] (20) CpxRNTS (21) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (22) CpxRNTS (23) IntTrsBoundProof [UPPER BOUND(ID), 195 ms] (24) CpxRNTS (25) IntTrsBoundProof [UPPER BOUND(ID), 25 ms] (26) CpxRNTS (27) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (28) CpxRNTS (29) IntTrsBoundProof [UPPER BOUND(ID), 110 ms] (30) CpxRNTS (31) IntTrsBoundProof [UPPER BOUND(ID), 4 ms] (32) CpxRNTS (33) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (34) CpxRNTS (35) IntTrsBoundProof [UPPER BOUND(ID), 335 ms] (36) CpxRNTS (37) IntTrsBoundProof [UPPER BOUND(ID), 45 ms] (38) CpxRNTS (39) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (40) CpxRNTS (41) IntTrsBoundProof [UPPER BOUND(ID), 62 ms] (42) CpxRNTS (43) IntTrsBoundProof [UPPER BOUND(ID), 44 ms] (44) CpxRNTS (45) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (46) CpxRNTS (47) IntTrsBoundProof [UPPER BOUND(ID), 183 ms] (48) CpxRNTS (49) IntTrsBoundProof [UPPER BOUND(ID), 54 ms] (50) CpxRNTS (51) ResultPropagationProof [UPPER BOUND(ID), 9 ms] (52) CpxRNTS (53) IntTrsBoundProof [UPPER BOUND(ID), 62.0 s] (54) CpxRNTS (55) IntTrsBoundProof [UPPER BOUND(ID), 30.6 s] (56) CpxRNTS (57) CompletionProof [UPPER BOUND(ID), 0 ms] (58) CpxTypedWeightedCompleteTrs (59) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 4 ms] (60) CpxRNTS (61) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms] (62) CdtProblem (63) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (64) CdtProblem (65) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (66) CdtProblem (67) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (68) CdtProblem (69) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (70) CdtProblem (71) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (72) CdtProblem (73) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 199 ms] (74) CdtProblem (75) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (76) CdtProblem (77) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (78) CdtProblem (79) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (80) CdtProblem (81) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (82) CdtProblem (83) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (84) CdtProblem (85) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (86) CdtProblem (87) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (88) CdtProblem (89) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (90) CdtProblem (91) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (92) CdtProblem (93) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (94) CdtProblem (95) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (96) CdtProblem (97) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (98) CdtProblem (99) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (100) CdtProblem (101) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (102) CdtProblem (103) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (104) CdtProblem (105) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (106) CdtProblem (107) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 4 ms] (108) CdtProblem (109) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (110) CdtProblem (111) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 792 ms] (112) CdtProblem (113) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 13 ms] (114) CdtProblem (115) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (116) CdtProblem (117) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (118) CdtProblem (119) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (120) CdtProblem (121) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (122) CdtProblem (123) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (124) CdtProblem (125) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 2 ms] (126) CdtProblem (127) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (128) CdtProblem (129) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (130) CdtProblem (131) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (132) CdtProblem (133) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (134) CdtProblem (135) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (136) CdtProblem (137) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (138) CdtProblem (139) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (140) CdtProblem (141) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (142) CdtProblem (143) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (144) CdtProblem (145) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (146) CdtProblem (147) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (148) CdtProblem (149) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (150) CdtProblem (151) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (152) CdtProblem (153) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (154) CdtProblem (155) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (156) CdtProblem (157) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (158) CdtProblem (159) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (160) CdtProblem (161) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (162) CdtProblem (163) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (164) CdtProblem (165) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (166) CdtProblem (167) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 15 ms] (168) CdtProblem (169) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (170) CdtProblem (171) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (172) CdtProblem (173) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (174) CdtProblem (175) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (176) CdtProblem (177) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (178) CdtProblem (179) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (180) CdtProblem (181) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (182) CdtProblem (183) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (184) CdtProblem (185) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (186) CdtProblem (187) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (188) CdtProblem (189) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (190) CdtProblem (191) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (192) CdtProblem (193) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (194) CdtProblem (195) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (196) CdtProblem (197) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 8 ms] (198) CdtProblem (199) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (200) CdtProblem (201) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 13 ms] (202) CdtProblem (203) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (204) CdtProblem (205) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 14 ms] (206) CdtProblem (207) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (208) CdtProblem (209) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (210) CdtProblem (211) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (212) CdtProblem (213) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (214) CdtProblem (215) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (216) CdtProblem (217) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 3 ms] (218) CdtProblem (219) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 16 ms] (220) CdtProblem (221) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (222) CdtProblem (223) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (224) CdtProblem (225) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (226) CdtProblem (227) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (228) CdtProblem (229) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (230) CdtProblem (231) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (232) CdtProblem (233) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 13 ms] (234) CdtProblem (235) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (236) CdtProblem (237) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (238) CdtProblem (239) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (240) CdtProblem (241) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (242) CdtProblem (243) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (244) CdtProblem ---------------------------------------- (0) Obligation: The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: isEmpty(empty) -> true isEmpty(node(l, x, r)) -> false left(empty) -> empty left(node(l, x, r)) -> l right(empty) -> empty right(node(l, x, r)) -> r elem(node(l, x, r)) -> x append(nil, x) -> cons(x, nil) append(cons(y, ys), x) -> cons(y, append(ys, x)) listify(n, xs) -> if(isEmpty(n), isEmpty(left(n)), right(n), node(left(left(n)), elem(left(n)), node(right(left(n)), elem(n), right(n))), xs, append(xs, n)) if(true, b, n, m, xs, ys) -> xs if(false, false, n, m, xs, ys) -> listify(m, xs) if(false, true, n, m, xs, ys) -> listify(n, ys) toList(n) -> listify(n, nil) S is empty. Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (1) RenamingProof (BOTH BOUNDS(ID, ID)) Renamed function symbols to avoid clashes with predefined symbol. ---------------------------------------- (2) Obligation: The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: isEmpty(empty) -> true isEmpty(node(l, x, r)) -> false left(empty) -> empty left(node(l, x, r)) -> l right(empty) -> empty right(node(l, x, r)) -> r elem(node(l, x, r)) -> x append(nil, x) -> cons(x, nil) append(cons(y, ys), x) -> cons(y, append(ys, x)) listify(n, xs) -> if(isEmpty(n), isEmpty(left(n)), right(n), node(left(left(n)), elem(left(n)), node(right(left(n)), elem(n), right(n))), xs, append(xs, n)) if(true, b, n, m, xs, ys) -> xs if(false, false, n, m, xs, ys) -> listify(m, xs) if(false, true, n, m, xs, ys) -> listify(n, ys) toList(n) -> listify(n, nil) S is empty. Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (3) RelTrsToTrsProof (UPPER BOUND(ID)) transformed relative TRS to TRS ---------------------------------------- (4) Obligation: The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: isEmpty(empty) -> true isEmpty(node(l, x, r)) -> false left(empty) -> empty left(node(l, x, r)) -> l right(empty) -> empty right(node(l, x, r)) -> r elem(node(l, x, r)) -> x append(nil, x) -> cons(x, nil) append(cons(y, ys), x) -> cons(y, append(ys, x)) listify(n, xs) -> if(isEmpty(n), isEmpty(left(n)), right(n), node(left(left(n)), elem(left(n)), node(right(left(n)), elem(n), right(n))), xs, append(xs, n)) if(true, b, n, m, xs, ys) -> xs if(false, false, n, m, xs, ys) -> listify(m, xs) if(false, true, n, m, xs, ys) -> listify(n, ys) toList(n) -> listify(n, nil) S is empty. Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (5) RelTrsToWeightedTrsProof (UPPER BOUND(ID)) Transformed relative TRS to weighted TRS ---------------------------------------- (6) Obligation: The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: isEmpty(empty) -> true [1] isEmpty(node(l, x, r)) -> false [1] left(empty) -> empty [1] left(node(l, x, r)) -> l [1] right(empty) -> empty [1] right(node(l, x, r)) -> r [1] elem(node(l, x, r)) -> x [1] append(nil, x) -> cons(x, nil) [1] append(cons(y, ys), x) -> cons(y, append(ys, x)) [1] listify(n, xs) -> if(isEmpty(n), isEmpty(left(n)), right(n), node(left(left(n)), elem(left(n)), node(right(left(n)), elem(n), right(n))), xs, append(xs, n)) [1] if(true, b, n, m, xs, ys) -> xs [1] if(false, false, n, m, xs, ys) -> listify(m, xs) [1] if(false, true, n, m, xs, ys) -> listify(n, ys) [1] toList(n) -> listify(n, nil) [1] Rewrite Strategy: INNERMOST ---------------------------------------- (7) TypeInferenceProof (BOTH BOUNDS(ID, ID)) Infered types. ---------------------------------------- (8) Obligation: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: isEmpty(empty) -> true [1] isEmpty(node(l, x, r)) -> false [1] left(empty) -> empty [1] left(node(l, x, r)) -> l [1] right(empty) -> empty [1] right(node(l, x, r)) -> r [1] elem(node(l, x, r)) -> x [1] append(nil, x) -> cons(x, nil) [1] append(cons(y, ys), x) -> cons(y, append(ys, x)) [1] listify(n, xs) -> if(isEmpty(n), isEmpty(left(n)), right(n), node(left(left(n)), elem(left(n)), node(right(left(n)), elem(n), right(n))), xs, append(xs, n)) [1] if(true, b, n, m, xs, ys) -> xs [1] if(false, false, n, m, xs, ys) -> listify(m, xs) [1] if(false, true, n, m, xs, ys) -> listify(n, ys) [1] toList(n) -> listify(n, nil) [1] The TRS has the following type information: isEmpty :: empty:node:y -> true:false empty :: empty:node:y true :: true:false node :: empty:node:y -> elem -> empty:node:y -> empty:node:y false :: true:false left :: empty:node:y -> empty:node:y right :: empty:node:y -> empty:node:y elem :: empty:node:y -> elem append :: nil:cons -> empty:node:y -> nil:cons nil :: nil:cons cons :: empty:node:y -> nil:cons -> nil:cons y :: empty:node:y listify :: empty:node:y -> nil:cons -> nil:cons if :: true:false -> true:false -> empty:node:y -> empty:node:y -> nil:cons -> nil:cons -> nil:cons toList :: empty:node:y -> nil:cons Rewrite Strategy: INNERMOST ---------------------------------------- (9) CompletionProof (UPPER BOUND(ID)) The transformation into a RNTS is sound, since: (a) The obligation is a constructor system where every type has a constant constructor, (b) The following defined symbols do not have to be completely defined, as they can never occur inside other defined symbols: listify_2 if_6 toList_1 (c) The following functions are completely defined: isEmpty_1 left_1 right_1 elem_1 append_2 Due to the following rules being added: isEmpty(v0) -> null_isEmpty [0] left(v0) -> null_left [0] right(v0) -> null_right [0] elem(v0) -> const [0] append(v0, v1) -> nil [0] And the following fresh constants: null_isEmpty, null_left, null_right, const ---------------------------------------- (10) Obligation: Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: isEmpty(empty) -> true [1] isEmpty(node(l, x, r)) -> false [1] left(empty) -> empty [1] left(node(l, x, r)) -> l [1] right(empty) -> empty [1] right(node(l, x, r)) -> r [1] elem(node(l, x, r)) -> x [1] append(nil, x) -> cons(x, nil) [1] append(cons(y, ys), x) -> cons(y, append(ys, x)) [1] listify(n, xs) -> if(isEmpty(n), isEmpty(left(n)), right(n), node(left(left(n)), elem(left(n)), node(right(left(n)), elem(n), right(n))), xs, append(xs, n)) [1] if(true, b, n, m, xs, ys) -> xs [1] if(false, false, n, m, xs, ys) -> listify(m, xs) [1] if(false, true, n, m, xs, ys) -> listify(n, ys) [1] toList(n) -> listify(n, nil) [1] isEmpty(v0) -> null_isEmpty [0] left(v0) -> null_left [0] right(v0) -> null_right [0] elem(v0) -> const [0] append(v0, v1) -> nil [0] The TRS has the following type information: isEmpty :: empty:node:y:null_left:null_right -> true:false:null_isEmpty empty :: empty:node:y:null_left:null_right true :: true:false:null_isEmpty node :: empty:node:y:null_left:null_right -> const -> empty:node:y:null_left:null_right -> empty:node:y:null_left:null_right false :: true:false:null_isEmpty left :: empty:node:y:null_left:null_right -> empty:node:y:null_left:null_right right :: empty:node:y:null_left:null_right -> empty:node:y:null_left:null_right elem :: empty:node:y:null_left:null_right -> const append :: nil:cons -> empty:node:y:null_left:null_right -> nil:cons nil :: nil:cons cons :: empty:node:y:null_left:null_right -> nil:cons -> nil:cons y :: empty:node:y:null_left:null_right listify :: empty:node:y:null_left:null_right -> nil:cons -> nil:cons if :: true:false:null_isEmpty -> true:false:null_isEmpty -> empty:node:y:null_left:null_right -> empty:node:y:null_left:null_right -> nil:cons -> nil:cons -> nil:cons toList :: empty:node:y:null_left:null_right -> nil:cons null_isEmpty :: true:false:null_isEmpty null_left :: empty:node:y:null_left:null_right null_right :: empty:node:y:null_left:null_right const :: const Rewrite Strategy: INNERMOST ---------------------------------------- (11) NarrowingProof (BOTH BOUNDS(ID, ID)) Narrowed the inner basic terms of all right-hand sides by a single narrowing step. ---------------------------------------- (12) Obligation: Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: isEmpty(empty) -> true [1] isEmpty(node(l, x, r)) -> false [1] left(empty) -> empty [1] left(node(l, x, r)) -> l [1] right(empty) -> empty [1] right(node(l, x, r)) -> r [1] elem(node(l, x, r)) -> x [1] append(nil, x) -> cons(x, nil) [1] append(cons(y, ys), x) -> cons(y, append(ys, x)) [1] listify(n, xs) -> if(isEmpty(n), isEmpty(left(n)), right(n), node(left(left(n)), elem(left(n)), node(right(left(n)), elem(n), right(n))), xs, append(xs, n)) [1] if(true, b, n, m, xs, ys) -> xs [1] if(false, false, n, m, xs, ys) -> listify(m, xs) [1] if(false, true, n, m, xs, ys) -> listify(n, ys) [1] toList(n) -> listify(n, nil) [1] isEmpty(v0) -> null_isEmpty [0] left(v0) -> null_left [0] right(v0) -> null_right [0] elem(v0) -> const [0] append(v0, v1) -> nil [0] The TRS has the following type information: isEmpty :: empty:node:y:null_left:null_right -> true:false:null_isEmpty empty :: empty:node:y:null_left:null_right true :: true:false:null_isEmpty node :: empty:node:y:null_left:null_right -> const -> empty:node:y:null_left:null_right -> empty:node:y:null_left:null_right false :: true:false:null_isEmpty left :: empty:node:y:null_left:null_right -> empty:node:y:null_left:null_right right :: empty:node:y:null_left:null_right -> empty:node:y:null_left:null_right elem :: empty:node:y:null_left:null_right -> const append :: nil:cons -> empty:node:y:null_left:null_right -> nil:cons nil :: nil:cons cons :: empty:node:y:null_left:null_right -> nil:cons -> nil:cons y :: empty:node:y:null_left:null_right listify :: empty:node:y:null_left:null_right -> nil:cons -> nil:cons if :: true:false:null_isEmpty -> true:false:null_isEmpty -> empty:node:y:null_left:null_right -> empty:node:y:null_left:null_right -> nil:cons -> nil:cons -> nil:cons toList :: empty:node:y:null_left:null_right -> nil:cons null_isEmpty :: true:false:null_isEmpty null_left :: empty:node:y:null_left:null_right null_right :: empty:node:y:null_left:null_right const :: const Rewrite Strategy: INNERMOST ---------------------------------------- (13) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID)) Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction. The constant constructors are abstracted as follows: empty => 0 true => 2 false => 1 nil => 0 y => 1 null_isEmpty => 0 null_left => 0 null_right => 0 const => 0 ---------------------------------------- (14) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 append(z, z') -{ 1 }-> 1 + x + 0 :|: z' = x, x >= 0, z = 0 append(z, z') -{ 1 }-> 1 + 1 + append(ys, x) :|: z' = x, ys >= 0, x >= 0, z = 1 + 1 + ys elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 if(z, z', z'', z1, z2, z3) -{ 1 }-> xs :|: z = 2, b >= 0, n >= 0, xs >= 0, z'' = n, z1 = m, ys >= 0, z' = b, z3 = ys, z2 = xs, m >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(m, xs) :|: n >= 0, xs >= 0, z'' = n, z = 1, z1 = m, ys >= 0, z' = 1, z3 = ys, z2 = xs, m >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(n, ys) :|: n >= 0, xs >= 0, z'' = n, z' = 2, z = 1, z1 = m, ys >= 0, z3 = ys, z2 = xs, m >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 listify(z, z') -{ 1 }-> if(isEmpty(n), isEmpty(left(n)), right(n), 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + elem(n) + right(n)), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 toList(z) -{ 1 }-> listify(n, 0) :|: n >= 0, z = n ---------------------------------------- (15) InliningProof (UPPER BOUND(ID)) Inlined the following terminating rules on right-hand sides where appropriate: isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 ---------------------------------------- (16) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 append(z, z') -{ 1 }-> 1 + x + 0 :|: z' = x, x >= 0, z = 0 append(z, z') -{ 1 }-> 1 + 1 + append(ys, x) :|: z' = x, ys >= 0, x >= 0, z = 1 + 1 + ys elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 if(z, z', z'', z1, z2, z3) -{ 1 }-> xs :|: z = 2, b >= 0, n >= 0, xs >= 0, z'' = n, z1 = m, ys >= 0, z' = b, z3 = ys, z2 = xs, m >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(m, xs) :|: n >= 0, xs >= 0, z'' = n, z = 1, z1 = m, ys >= 0, z' = 1, z3 = ys, z2 = xs, m >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(n, ys) :|: n >= 0, xs >= 0, z'' = n, z' = 2, z = 1, z1 = m, ys >= 0, z3 = ys, z2 = xs, m >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 listify(z, z') -{ 4 }-> if(2, isEmpty(left(n)), 0, 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + 0 + 0), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, n = 0, v0 >= 0, n = v0 listify(z, z') -{ 3 }-> if(2, isEmpty(left(n)), 0, 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + 0 + 0), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, n = 0, v0 >= 0, n = v0, v0' >= 0, n = v0' listify(z, z') -{ 2 }-> if(2, isEmpty(left(n)), 0, 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + 0 + 0), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, n = 0, v0 >= 0, n = v0, v0' >= 0, n = v0', v0'' >= 0, n = v0'' listify(z, z') -{ 4 }-> if(1, isEmpty(left(n)), r', 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + x'' + 0), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, r >= 0, x >= 0, l >= 0, n = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, n = 1 + l' + x' + r', v0 >= 0, n = v0, r'' >= 0, x'' >= 0, l'' >= 0, n = 1 + l'' + x'' + r'' listify(z, z') -{ 5 }-> if(1, isEmpty(left(n)), r', 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + x1 + r''), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, r >= 0, x >= 0, l >= 0, n = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, n = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, n = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, n = 1 + l1 + x1 + r1 listify(z, z') -{ 4 }-> if(1, isEmpty(left(n)), r', 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + 0 + r''), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, r >= 0, x >= 0, l >= 0, n = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, n = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, n = 1 + l'' + x'' + r'', v0 >= 0, n = v0 listify(z, z') -{ 3 }-> if(1, isEmpty(left(n)), r', 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + 0 + 0), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, r >= 0, x >= 0, l >= 0, n = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, n = 1 + l' + x' + r', v0 >= 0, n = v0, v0' >= 0, n = v0' listify(z, z') -{ 3 }-> if(1, isEmpty(left(n)), 0, 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + x' + 0), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, r >= 0, x >= 0, l >= 0, n = 1 + l + x + r, v0 >= 0, n = v0, v0' >= 0, n = v0', r' >= 0, x' >= 0, l' >= 0, n = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(1, isEmpty(left(n)), 0, 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + x'' + r'), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, r >= 0, x >= 0, l >= 0, n = 1 + l + x + r, v0 >= 0, n = v0, r' >= 0, x' >= 0, l' >= 0, n = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, n = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(n)), 0, 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + 0 + r'), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, r >= 0, x >= 0, l >= 0, n = 1 + l + x + r, v0 >= 0, n = v0, r' >= 0, x' >= 0, l' >= 0, n = 1 + l' + x' + r', v0' >= 0, n = v0' listify(z, z') -{ 2 }-> if(1, isEmpty(left(n)), 0, 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + 0 + 0), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, r >= 0, x >= 0, l >= 0, n = 1 + l + x + r, v0 >= 0, n = v0, v0' >= 0, n = v0', v0'' >= 0, n = v0'' listify(z, z') -{ 3 }-> if(0, isEmpty(left(n)), r, 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + x' + 0), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, v0 >= 0, n = v0, r >= 0, x >= 0, l >= 0, n = 1 + l + x + r, v0' >= 0, n = v0', r' >= 0, x' >= 0, l' >= 0, n = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(0, isEmpty(left(n)), r, 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + x'' + r'), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, v0 >= 0, n = v0, r >= 0, x >= 0, l >= 0, n = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, n = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, n = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(0, isEmpty(left(n)), r, 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + 0 + r'), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, v0 >= 0, n = v0, r >= 0, x >= 0, l >= 0, n = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, n = 1 + l' + x' + r', v0' >= 0, n = v0' listify(z, z') -{ 2 }-> if(0, isEmpty(left(n)), r, 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + 0 + 0), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, v0 >= 0, n = v0, r >= 0, x >= 0, l >= 0, n = 1 + l + x + r, v0' >= 0, n = v0', v0'' >= 0, n = v0'' listify(z, z') -{ 2 }-> if(0, isEmpty(left(n)), 0, 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + x + 0), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, v0 >= 0, n = v0, v0' >= 0, n = v0', v0'' >= 0, n = v0'', r >= 0, x >= 0, l >= 0, n = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(n)), 0, 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + x' + r), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, v0 >= 0, n = v0, v0' >= 0, n = v0', r >= 0, x >= 0, l >= 0, n = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, n = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(n)), 0, 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + 0 + r), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, v0 >= 0, n = v0, v0' >= 0, n = v0', r >= 0, x >= 0, l >= 0, n = 1 + l + x + r, v0'' >= 0, n = v0'' listify(z, z') -{ 3 }-> if(0, isEmpty(left(n)), 0, 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + 0 + 0), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, v0 >= 0, n = v0, n = 0, v0' >= 0, n = v0' listify(z, z') -{ 2 }-> if(0, isEmpty(left(n)), 0, 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + 0 + 0), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, v0 >= 0, n = v0, n = 0, v0' >= 0, n = v0', v0'' >= 0, n = v0'' listify(z, z') -{ 1 }-> if(0, isEmpty(left(n)), 0, 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + 0 + 0), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs, v0 >= 0, n = v0, v0' >= 0, n = v0', v0'' >= 0, n = v0'', v01 >= 0, n = v01 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 toList(z) -{ 1 }-> listify(n, 0) :|: n >= 0, z = n ---------------------------------------- (17) SimplificationProof (BOTH BOUNDS(ID, ID)) Simplified the RNTS by moving equalities from the constraints into the right-hand sides. ---------------------------------------- (18) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ 1 }-> 1 + 1 + append(z - 2, z') :|: z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 4 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 5 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x1 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 1 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 ---------------------------------------- (19) CpxRntsAnalysisOrderProof (BOTH BOUNDS(ID, ID)) Found the following analysis order by SCC decomposition: { isEmpty } { elem } { append } { right } { left } { listify, if } { toList } ---------------------------------------- (20) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ 1 }-> 1 + 1 + append(z - 2, z') :|: z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 4 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 5 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x1 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 1 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {isEmpty}, {elem}, {append}, {right}, {left}, {listify,if}, {toList} ---------------------------------------- (21) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (22) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ 1 }-> 1 + 1 + append(z - 2, z') :|: z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 4 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 5 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x1 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 1 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {isEmpty}, {elem}, {append}, {right}, {left}, {listify,if}, {toList} ---------------------------------------- (23) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: isEmpty after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 2 ---------------------------------------- (24) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ 1 }-> 1 + 1 + append(z - 2, z') :|: z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 4 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 5 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x1 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 1 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {isEmpty}, {elem}, {append}, {right}, {left}, {listify,if}, {toList} Previous analysis results are: isEmpty: runtime: ?, size: O(1) [2] ---------------------------------------- (25) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: isEmpty after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (26) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ 1 }-> 1 + 1 + append(z - 2, z') :|: z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 4 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 5 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x1 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 1 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {elem}, {append}, {right}, {left}, {listify,if}, {toList} Previous analysis results are: isEmpty: runtime: O(1) [1], size: O(1) [2] ---------------------------------------- (27) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (28) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ 1 }-> 1 + 1 + append(z - 2, z') :|: z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 4 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 5 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x1 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 1 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {elem}, {append}, {right}, {left}, {listify,if}, {toList} Previous analysis results are: isEmpty: runtime: O(1) [1], size: O(1) [2] ---------------------------------------- (29) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using KoAT for: elem after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z ---------------------------------------- (30) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ 1 }-> 1 + 1 + append(z - 2, z') :|: z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 4 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 5 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x1 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 1 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {elem}, {append}, {right}, {left}, {listify,if}, {toList} Previous analysis results are: isEmpty: runtime: O(1) [1], size: O(1) [2] elem: runtime: ?, size: O(n^1) [z] ---------------------------------------- (31) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: elem after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (32) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ 1 }-> 1 + 1 + append(z - 2, z') :|: z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 4 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 5 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x1 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 1 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {append}, {right}, {left}, {listify,if}, {toList} Previous analysis results are: isEmpty: runtime: O(1) [1], size: O(1) [2] elem: runtime: O(1) [1], size: O(n^1) [z] ---------------------------------------- (33) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (34) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ 1 }-> 1 + 1 + append(z - 2, z') :|: z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 4 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 5 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x1 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 1 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {append}, {right}, {left}, {listify,if}, {toList} Previous analysis results are: isEmpty: runtime: O(1) [1], size: O(1) [2] elem: runtime: O(1) [1], size: O(n^1) [z] ---------------------------------------- (35) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: append after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 1 + z + z' ---------------------------------------- (36) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ 1 }-> 1 + 1 + append(z - 2, z') :|: z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 4 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 5 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x1 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 1 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {append}, {right}, {left}, {listify,if}, {toList} Previous analysis results are: isEmpty: runtime: O(1) [1], size: O(1) [2] elem: runtime: O(1) [1], size: O(n^1) [z] append: runtime: ?, size: O(n^1) [1 + z + z'] ---------------------------------------- (37) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using KoAT for: append after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 1 + z ---------------------------------------- (38) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ 1 }-> 1 + 1 + append(z - 2, z') :|: z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 4 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 5 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x1 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r''), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x + 0), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r), z', append(z', z)) :|: z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 2 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0, z = 0 listify(z, z') -{ 1 }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', append(z', z)) :|: z >= 0, z' >= 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {right}, {left}, {listify,if}, {toList} Previous analysis results are: isEmpty: runtime: O(1) [1], size: O(1) [2] elem: runtime: O(1) [1], size: O(n^1) [z] append: runtime: O(n^1) [1 + z], size: O(n^1) [1 + z + z'] ---------------------------------------- (39) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (40) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ z }-> 1 + 1 + s :|: s >= 0, s <= z - 2 + z' + 1, z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 5 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s') :|: s' >= 0, s' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 4 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s'') :|: s'' >= 0, s'' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s1) :|: s1 >= 0, s1 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + 0), z', s14) :|: s14 >= 0, s14 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 6 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x1 + r''), z', s12) :|: s12 >= 0, s12 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r''), z', s13) :|: s13 >= 0, s13 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s15) :|: s15 >= 0, s15 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', s18) :|: s18 >= 0, s18 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', s16) :|: s16 >= 0, s16 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', s17) :|: s17 >= 0, s17 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s19) :|: s19 >= 0, s19 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', s6) :|: s6 >= 0, s6 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 5 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', s4) :|: s4 >= 0, s4 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', s5) :|: s5 >= 0, s5 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s7) :|: s7 >= 0, s7 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x + 0), z', s10) :|: s10 >= 0, s10 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + r), z', s8) :|: s8 >= 0, s8 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r), z', s9) :|: s9 >= 0, s9 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 2 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s11) :|: s11 >= 0, s11 <= z' + z + 1, z >= 0, z' >= 0 listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s2) :|: s2 >= 0, s2 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s3) :|: s3 >= 0, s3 <= z' + z + 1, z >= 0, z' >= 0, z = 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {right}, {left}, {listify,if}, {toList} Previous analysis results are: isEmpty: runtime: O(1) [1], size: O(1) [2] elem: runtime: O(1) [1], size: O(n^1) [z] append: runtime: O(n^1) [1 + z], size: O(n^1) [1 + z + z'] ---------------------------------------- (41) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using KoAT for: right after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z ---------------------------------------- (42) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ z }-> 1 + 1 + s :|: s >= 0, s <= z - 2 + z' + 1, z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 5 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s') :|: s' >= 0, s' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 4 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s'') :|: s'' >= 0, s'' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s1) :|: s1 >= 0, s1 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + 0), z', s14) :|: s14 >= 0, s14 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 6 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x1 + r''), z', s12) :|: s12 >= 0, s12 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r''), z', s13) :|: s13 >= 0, s13 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s15) :|: s15 >= 0, s15 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', s18) :|: s18 >= 0, s18 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', s16) :|: s16 >= 0, s16 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', s17) :|: s17 >= 0, s17 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s19) :|: s19 >= 0, s19 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', s6) :|: s6 >= 0, s6 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 5 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', s4) :|: s4 >= 0, s4 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', s5) :|: s5 >= 0, s5 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s7) :|: s7 >= 0, s7 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x + 0), z', s10) :|: s10 >= 0, s10 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + r), z', s8) :|: s8 >= 0, s8 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r), z', s9) :|: s9 >= 0, s9 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 2 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s11) :|: s11 >= 0, s11 <= z' + z + 1, z >= 0, z' >= 0 listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s2) :|: s2 >= 0, s2 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s3) :|: s3 >= 0, s3 <= z' + z + 1, z >= 0, z' >= 0, z = 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {right}, {left}, {listify,if}, {toList} Previous analysis results are: isEmpty: runtime: O(1) [1], size: O(1) [2] elem: runtime: O(1) [1], size: O(n^1) [z] append: runtime: O(n^1) [1 + z], size: O(n^1) [1 + z + z'] right: runtime: ?, size: O(n^1) [z] ---------------------------------------- (43) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: right after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (44) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ z }-> 1 + 1 + s :|: s >= 0, s <= z - 2 + z' + 1, z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 5 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s') :|: s' >= 0, s' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 4 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s'') :|: s'' >= 0, s'' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s1) :|: s1 >= 0, s1 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + 0), z', s14) :|: s14 >= 0, s14 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 6 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x1 + r''), z', s12) :|: s12 >= 0, s12 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r''), z', s13) :|: s13 >= 0, s13 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s15) :|: s15 >= 0, s15 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', s18) :|: s18 >= 0, s18 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', s16) :|: s16 >= 0, s16 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', s17) :|: s17 >= 0, s17 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s19) :|: s19 >= 0, s19 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', s6) :|: s6 >= 0, s6 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 5 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', s4) :|: s4 >= 0, s4 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', s5) :|: s5 >= 0, s5 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s7) :|: s7 >= 0, s7 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x + 0), z', s10) :|: s10 >= 0, s10 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + r), z', s8) :|: s8 >= 0, s8 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r), z', s9) :|: s9 >= 0, s9 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 2 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s11) :|: s11 >= 0, s11 <= z' + z + 1, z >= 0, z' >= 0 listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s2) :|: s2 >= 0, s2 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s3) :|: s3 >= 0, s3 <= z' + z + 1, z >= 0, z' >= 0, z = 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {left}, {listify,if}, {toList} Previous analysis results are: isEmpty: runtime: O(1) [1], size: O(1) [2] elem: runtime: O(1) [1], size: O(n^1) [z] append: runtime: O(n^1) [1 + z], size: O(n^1) [1 + z + z'] right: runtime: O(1) [1], size: O(n^1) [z] ---------------------------------------- (45) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (46) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ z }-> 1 + 1 + s :|: s >= 0, s <= z - 2 + z' + 1, z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 5 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s') :|: s' >= 0, s' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 4 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s'') :|: s'' >= 0, s'' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s1) :|: s1 >= 0, s1 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + 0), z', s14) :|: s14 >= 0, s14 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 6 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x1 + r''), z', s12) :|: s12 >= 0, s12 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r''), z', s13) :|: s13 >= 0, s13 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s15) :|: s15 >= 0, s15 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', s18) :|: s18 >= 0, s18 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', s16) :|: s16 >= 0, s16 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', s17) :|: s17 >= 0, s17 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s19) :|: s19 >= 0, s19 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', s6) :|: s6 >= 0, s6 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 5 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', s4) :|: s4 >= 0, s4 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', s5) :|: s5 >= 0, s5 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s7) :|: s7 >= 0, s7 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x + 0), z', s10) :|: s10 >= 0, s10 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + r), z', s8) :|: s8 >= 0, s8 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r), z', s9) :|: s9 >= 0, s9 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 2 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s11) :|: s11 >= 0, s11 <= z' + z + 1, z >= 0, z' >= 0 listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s2) :|: s2 >= 0, s2 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s3) :|: s3 >= 0, s3 <= z' + z + 1, z >= 0, z' >= 0, z = 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {left}, {listify,if}, {toList} Previous analysis results are: isEmpty: runtime: O(1) [1], size: O(1) [2] elem: runtime: O(1) [1], size: O(n^1) [z] append: runtime: O(n^1) [1 + z], size: O(n^1) [1 + z + z'] right: runtime: O(1) [1], size: O(n^1) [z] ---------------------------------------- (47) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using KoAT for: left after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z ---------------------------------------- (48) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ z }-> 1 + 1 + s :|: s >= 0, s <= z - 2 + z' + 1, z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 5 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s') :|: s' >= 0, s' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 4 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s'') :|: s'' >= 0, s'' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s1) :|: s1 >= 0, s1 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + 0), z', s14) :|: s14 >= 0, s14 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 6 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x1 + r''), z', s12) :|: s12 >= 0, s12 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r''), z', s13) :|: s13 >= 0, s13 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s15) :|: s15 >= 0, s15 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', s18) :|: s18 >= 0, s18 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', s16) :|: s16 >= 0, s16 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', s17) :|: s17 >= 0, s17 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s19) :|: s19 >= 0, s19 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', s6) :|: s6 >= 0, s6 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 5 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', s4) :|: s4 >= 0, s4 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', s5) :|: s5 >= 0, s5 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s7) :|: s7 >= 0, s7 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x + 0), z', s10) :|: s10 >= 0, s10 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + r), z', s8) :|: s8 >= 0, s8 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r), z', s9) :|: s9 >= 0, s9 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 2 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s11) :|: s11 >= 0, s11 <= z' + z + 1, z >= 0, z' >= 0 listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s2) :|: s2 >= 0, s2 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s3) :|: s3 >= 0, s3 <= z' + z + 1, z >= 0, z' >= 0, z = 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {left}, {listify,if}, {toList} Previous analysis results are: isEmpty: runtime: O(1) [1], size: O(1) [2] elem: runtime: O(1) [1], size: O(n^1) [z] append: runtime: O(n^1) [1 + z], size: O(n^1) [1 + z + z'] right: runtime: O(1) [1], size: O(n^1) [z] left: runtime: ?, size: O(n^1) [z] ---------------------------------------- (49) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: left after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (50) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ z }-> 1 + 1 + s :|: s >= 0, s <= z - 2 + z' + 1, z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 5 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s') :|: s' >= 0, s' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 4 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s'') :|: s'' >= 0, s'' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 + z' }-> if(2, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s1) :|: s1 >= 0, s1 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + 0), z', s14) :|: s14 >= 0, s14 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 6 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x1 + r''), z', s12) :|: s12 >= 0, s12 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r''), z', s13) :|: s13 >= 0, s13 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), r', 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s15) :|: s15 >= 0, s15 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', s18) :|: s18 >= 0, s18 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 5 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', s16) :|: s16 >= 0, s16 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', s17) :|: s17 >= 0, s17 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(1, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s19) :|: s19 >= 0, s19 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + 0), z', s6) :|: s6 >= 0, s6 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 5 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x'' + r'), z', s4) :|: s4 >= 0, s4 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r'), z', s5) :|: s5 >= 0, s5 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), r, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s7) :|: s7 >= 0, s7 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x + 0), z', s10) :|: s10 >= 0, s10 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + x' + r), z', s8) :|: s8 >= 0, s8 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + r), z', s9) :|: s9 >= 0, s9 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 2 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s11) :|: s11 >= 0, s11 <= z' + z + 1, z >= 0, z' >= 0 listify(z, z') -{ 4 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s2) :|: s2 >= 0, s2 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 3 + z' }-> if(0, isEmpty(left(z)), 0, 1 + left(left(z)) + elem(left(z)) + (1 + right(left(z)) + 0 + 0), z', s3) :|: s3 >= 0, s3 <= z' + z + 1, z >= 0, z' >= 0, z = 0 right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {listify,if}, {toList} Previous analysis results are: isEmpty: runtime: O(1) [1], size: O(1) [2] elem: runtime: O(1) [1], size: O(n^1) [z] append: runtime: O(n^1) [1 + z], size: O(n^1) [1 + z + z'] right: runtime: O(1) [1], size: O(n^1) [z] left: runtime: O(1) [1], size: O(n^1) [z] ---------------------------------------- (51) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (52) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ z }-> 1 + 1 + s :|: s >= 0, s <= z - 2 + z' + 1, z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 13 + z' }-> if(2, s21, 0, 1 + s23 + s25 + (1 + s27 + 0 + 0), z', s') :|: s20 >= 0, s20 <= z, s21 >= 0, s21 <= 2, s22 >= 0, s22 <= z, s23 >= 0, s23 <= s22, s24 >= 0, s24 <= z, s25 >= 0, s25 <= s24, s26 >= 0, s26 <= z, s27 >= 0, s27 <= s26, s' >= 0, s' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 12 + z' }-> if(2, s29, 0, 1 + s31 + s33 + (1 + s35 + 0 + 0), z', s'') :|: s28 >= 0, s28 <= z, s29 >= 0, s29 <= 2, s30 >= 0, s30 <= z, s31 >= 0, s31 <= s30, s32 >= 0, s32 <= z, s33 >= 0, s33 <= s32, s34 >= 0, s34 <= z, s35 >= 0, s35 <= s34, s'' >= 0, s'' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 11 + z' }-> if(2, s37, 0, 1 + s39 + s41 + (1 + s43 + 0 + 0), z', s1) :|: s36 >= 0, s36 <= z, s37 >= 0, s37 <= 2, s38 >= 0, s38 <= z, s39 >= 0, s39 <= s38, s40 >= 0, s40 <= z, s41 >= 0, s41 <= s40, s42 >= 0, s42 <= z, s43 >= 0, s43 <= s42, s1 >= 0, s1 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 14 + z' }-> if(1, s125, r', 1 + s127 + s129 + (1 + s131 + x1 + r''), z', s12) :|: s124 >= 0, s124 <= z, s125 >= 0, s125 <= 2, s126 >= 0, s126 <= z, s127 >= 0, s127 <= s126, s128 >= 0, s128 <= z, s129 >= 0, s129 <= s128, s130 >= 0, s130 <= z, s131 >= 0, s131 <= s130, s12 >= 0, s12 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 13 + z' }-> if(1, s133, r', 1 + s135 + s137 + (1 + s139 + 0 + r''), z', s13) :|: s132 >= 0, s132 <= z, s133 >= 0, s133 <= 2, s134 >= 0, s134 <= z, s135 >= 0, s135 <= s134, s136 >= 0, s136 <= z, s137 >= 0, s137 <= s136, s138 >= 0, s138 <= z, s139 >= 0, s139 <= s138, s13 >= 0, s13 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 13 + z' }-> if(1, s141, r', 1 + s143 + s145 + (1 + s147 + x'' + 0), z', s14) :|: s140 >= 0, s140 <= z, s141 >= 0, s141 <= 2, s142 >= 0, s142 <= z, s143 >= 0, s143 <= s142, s144 >= 0, s144 <= z, s145 >= 0, s145 <= s144, s146 >= 0, s146 <= z, s147 >= 0, s147 <= s146, s14 >= 0, s14 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 12 + z' }-> if(1, s149, r', 1 + s151 + s153 + (1 + s155 + 0 + 0), z', s15) :|: s148 >= 0, s148 <= z, s149 >= 0, s149 <= 2, s150 >= 0, s150 <= z, s151 >= 0, s151 <= s150, s152 >= 0, s152 <= z, s153 >= 0, s153 <= s152, s154 >= 0, s154 <= z, s155 >= 0, s155 <= s154, s15 >= 0, s15 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 13 + z' }-> if(1, s157, 0, 1 + s159 + s161 + (1 + s163 + x'' + r'), z', s16) :|: s156 >= 0, s156 <= z, s157 >= 0, s157 <= 2, s158 >= 0, s158 <= z, s159 >= 0, s159 <= s158, s160 >= 0, s160 <= z, s161 >= 0, s161 <= s160, s162 >= 0, s162 <= z, s163 >= 0, s163 <= s162, s16 >= 0, s16 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 12 + z' }-> if(1, s165, 0, 1 + s167 + s169 + (1 + s171 + 0 + r'), z', s17) :|: s164 >= 0, s164 <= z, s165 >= 0, s165 <= 2, s166 >= 0, s166 <= z, s167 >= 0, s167 <= s166, s168 >= 0, s168 <= z, s169 >= 0, s169 <= s168, s170 >= 0, s170 <= z, s171 >= 0, s171 <= s170, s17 >= 0, s17 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 12 + z' }-> if(1, s173, 0, 1 + s175 + s177 + (1 + s179 + x' + 0), z', s18) :|: s172 >= 0, s172 <= z, s173 >= 0, s173 <= 2, s174 >= 0, s174 <= z, s175 >= 0, s175 <= s174, s176 >= 0, s176 <= z, s177 >= 0, s177 <= s176, s178 >= 0, s178 <= z, s179 >= 0, s179 <= s178, s18 >= 0, s18 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 11 + z' }-> if(1, s181, 0, 1 + s183 + s185 + (1 + s187 + 0 + 0), z', s19) :|: s180 >= 0, s180 <= z, s181 >= 0, s181 <= 2, s182 >= 0, s182 <= z, s183 >= 0, s183 <= s182, s184 >= 0, s184 <= z, s185 >= 0, s185 <= s184, s186 >= 0, s186 <= z, s187 >= 0, s187 <= s186, s19 >= 0, s19 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 11 + z' }-> if(0, s101, 0, 1 + s103 + s105 + (1 + s107 + 0 + r), z', s9) :|: s100 >= 0, s100 <= z, s101 >= 0, s101 <= 2, s102 >= 0, s102 <= z, s103 >= 0, s103 <= s102, s104 >= 0, s104 <= z, s105 >= 0, s105 <= s104, s106 >= 0, s106 <= z, s107 >= 0, s107 <= s106, s9 >= 0, s9 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 11 + z' }-> if(0, s109, 0, 1 + s111 + s113 + (1 + s115 + x + 0), z', s10) :|: s108 >= 0, s108 <= z, s109 >= 0, s109 <= 2, s110 >= 0, s110 <= z, s111 >= 0, s111 <= s110, s112 >= 0, s112 <= z, s113 >= 0, s113 <= s112, s114 >= 0, s114 <= z, s115 >= 0, s115 <= s114, s10 >= 0, s10 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 10 + z' }-> if(0, s117, 0, 1 + s119 + s121 + (1 + s123 + 0 + 0), z', s11) :|: s116 >= 0, s116 <= z, s117 >= 0, s117 <= 2, s118 >= 0, s118 <= z, s119 >= 0, s119 <= s118, s120 >= 0, s120 <= z, s121 >= 0, s121 <= s120, s122 >= 0, s122 <= z, s123 >= 0, s123 <= s122, s11 >= 0, s11 <= z' + z + 1, z >= 0, z' >= 0 listify(z, z') -{ 12 + z' }-> if(0, s45, 0, 1 + s47 + s49 + (1 + s51 + 0 + 0), z', s2) :|: s44 >= 0, s44 <= z, s45 >= 0, s45 <= 2, s46 >= 0, s46 <= z, s47 >= 0, s47 <= s46, s48 >= 0, s48 <= z, s49 >= 0, s49 <= s48, s50 >= 0, s50 <= z, s51 >= 0, s51 <= s50, s2 >= 0, s2 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 11 + z' }-> if(0, s53, 0, 1 + s55 + s57 + (1 + s59 + 0 + 0), z', s3) :|: s52 >= 0, s52 <= z, s53 >= 0, s53 <= 2, s54 >= 0, s54 <= z, s55 >= 0, s55 <= s54, s56 >= 0, s56 <= z, s57 >= 0, s57 <= s56, s58 >= 0, s58 <= z, s59 >= 0, s59 <= s58, s3 >= 0, s3 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 13 + z' }-> if(0, s61, r, 1 + s63 + s65 + (1 + s67 + x'' + r'), z', s4) :|: s60 >= 0, s60 <= z, s61 >= 0, s61 <= 2, s62 >= 0, s62 <= z, s63 >= 0, s63 <= s62, s64 >= 0, s64 <= z, s65 >= 0, s65 <= s64, s66 >= 0, s66 <= z, s67 >= 0, s67 <= s66, s4 >= 0, s4 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 12 + z' }-> if(0, s69, r, 1 + s71 + s73 + (1 + s75 + 0 + r'), z', s5) :|: s68 >= 0, s68 <= z, s69 >= 0, s69 <= 2, s70 >= 0, s70 <= z, s71 >= 0, s71 <= s70, s72 >= 0, s72 <= z, s73 >= 0, s73 <= s72, s74 >= 0, s74 <= z, s75 >= 0, s75 <= s74, s5 >= 0, s5 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 12 + z' }-> if(0, s77, r, 1 + s79 + s81 + (1 + s83 + x' + 0), z', s6) :|: s76 >= 0, s76 <= z, s77 >= 0, s77 <= 2, s78 >= 0, s78 <= z, s79 >= 0, s79 <= s78, s80 >= 0, s80 <= z, s81 >= 0, s81 <= s80, s82 >= 0, s82 <= z, s83 >= 0, s83 <= s82, s6 >= 0, s6 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 11 + z' }-> if(0, s85, r, 1 + s87 + s89 + (1 + s91 + 0 + 0), z', s7) :|: s84 >= 0, s84 <= z, s85 >= 0, s85 <= 2, s86 >= 0, s86 <= z, s87 >= 0, s87 <= s86, s88 >= 0, s88 <= z, s89 >= 0, s89 <= s88, s90 >= 0, s90 <= z, s91 >= 0, s91 <= s90, s7 >= 0, s7 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 12 + z' }-> if(0, s93, 0, 1 + s95 + s97 + (1 + s99 + x' + r), z', s8) :|: s92 >= 0, s92 <= z, s93 >= 0, s93 <= 2, s94 >= 0, s94 <= z, s95 >= 0, s95 <= s94, s96 >= 0, s96 <= z, s97 >= 0, s97 <= s96, s98 >= 0, s98 <= z, s99 >= 0, s99 <= s98, s8 >= 0, s8 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {listify,if}, {toList} Previous analysis results are: isEmpty: runtime: O(1) [1], size: O(1) [2] elem: runtime: O(1) [1], size: O(n^1) [z] append: runtime: O(n^1) [1 + z], size: O(n^1) [1 + z + z'] right: runtime: O(1) [1], size: O(n^1) [z] left: runtime: O(1) [1], size: O(n^1) [z] ---------------------------------------- (53) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: listify after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? Computed SIZE bound using CoFloCo for: if after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (54) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ z }-> 1 + 1 + s :|: s >= 0, s <= z - 2 + z' + 1, z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 13 + z' }-> if(2, s21, 0, 1 + s23 + s25 + (1 + s27 + 0 + 0), z', s') :|: s20 >= 0, s20 <= z, s21 >= 0, s21 <= 2, s22 >= 0, s22 <= z, s23 >= 0, s23 <= s22, s24 >= 0, s24 <= z, s25 >= 0, s25 <= s24, s26 >= 0, s26 <= z, s27 >= 0, s27 <= s26, s' >= 0, s' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 12 + z' }-> if(2, s29, 0, 1 + s31 + s33 + (1 + s35 + 0 + 0), z', s'') :|: s28 >= 0, s28 <= z, s29 >= 0, s29 <= 2, s30 >= 0, s30 <= z, s31 >= 0, s31 <= s30, s32 >= 0, s32 <= z, s33 >= 0, s33 <= s32, s34 >= 0, s34 <= z, s35 >= 0, s35 <= s34, s'' >= 0, s'' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 11 + z' }-> if(2, s37, 0, 1 + s39 + s41 + (1 + s43 + 0 + 0), z', s1) :|: s36 >= 0, s36 <= z, s37 >= 0, s37 <= 2, s38 >= 0, s38 <= z, s39 >= 0, s39 <= s38, s40 >= 0, s40 <= z, s41 >= 0, s41 <= s40, s42 >= 0, s42 <= z, s43 >= 0, s43 <= s42, s1 >= 0, s1 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 14 + z' }-> if(1, s125, r', 1 + s127 + s129 + (1 + s131 + x1 + r''), z', s12) :|: s124 >= 0, s124 <= z, s125 >= 0, s125 <= 2, s126 >= 0, s126 <= z, s127 >= 0, s127 <= s126, s128 >= 0, s128 <= z, s129 >= 0, s129 <= s128, s130 >= 0, s130 <= z, s131 >= 0, s131 <= s130, s12 >= 0, s12 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 13 + z' }-> if(1, s133, r', 1 + s135 + s137 + (1 + s139 + 0 + r''), z', s13) :|: s132 >= 0, s132 <= z, s133 >= 0, s133 <= 2, s134 >= 0, s134 <= z, s135 >= 0, s135 <= s134, s136 >= 0, s136 <= z, s137 >= 0, s137 <= s136, s138 >= 0, s138 <= z, s139 >= 0, s139 <= s138, s13 >= 0, s13 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 13 + z' }-> if(1, s141, r', 1 + s143 + s145 + (1 + s147 + x'' + 0), z', s14) :|: s140 >= 0, s140 <= z, s141 >= 0, s141 <= 2, s142 >= 0, s142 <= z, s143 >= 0, s143 <= s142, s144 >= 0, s144 <= z, s145 >= 0, s145 <= s144, s146 >= 0, s146 <= z, s147 >= 0, s147 <= s146, s14 >= 0, s14 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 12 + z' }-> if(1, s149, r', 1 + s151 + s153 + (1 + s155 + 0 + 0), z', s15) :|: s148 >= 0, s148 <= z, s149 >= 0, s149 <= 2, s150 >= 0, s150 <= z, s151 >= 0, s151 <= s150, s152 >= 0, s152 <= z, s153 >= 0, s153 <= s152, s154 >= 0, s154 <= z, s155 >= 0, s155 <= s154, s15 >= 0, s15 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 13 + z' }-> if(1, s157, 0, 1 + s159 + s161 + (1 + s163 + x'' + r'), z', s16) :|: s156 >= 0, s156 <= z, s157 >= 0, s157 <= 2, s158 >= 0, s158 <= z, s159 >= 0, s159 <= s158, s160 >= 0, s160 <= z, s161 >= 0, s161 <= s160, s162 >= 0, s162 <= z, s163 >= 0, s163 <= s162, s16 >= 0, s16 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 12 + z' }-> if(1, s165, 0, 1 + s167 + s169 + (1 + s171 + 0 + r'), z', s17) :|: s164 >= 0, s164 <= z, s165 >= 0, s165 <= 2, s166 >= 0, s166 <= z, s167 >= 0, s167 <= s166, s168 >= 0, s168 <= z, s169 >= 0, s169 <= s168, s170 >= 0, s170 <= z, s171 >= 0, s171 <= s170, s17 >= 0, s17 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 12 + z' }-> if(1, s173, 0, 1 + s175 + s177 + (1 + s179 + x' + 0), z', s18) :|: s172 >= 0, s172 <= z, s173 >= 0, s173 <= 2, s174 >= 0, s174 <= z, s175 >= 0, s175 <= s174, s176 >= 0, s176 <= z, s177 >= 0, s177 <= s176, s178 >= 0, s178 <= z, s179 >= 0, s179 <= s178, s18 >= 0, s18 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 11 + z' }-> if(1, s181, 0, 1 + s183 + s185 + (1 + s187 + 0 + 0), z', s19) :|: s180 >= 0, s180 <= z, s181 >= 0, s181 <= 2, s182 >= 0, s182 <= z, s183 >= 0, s183 <= s182, s184 >= 0, s184 <= z, s185 >= 0, s185 <= s184, s186 >= 0, s186 <= z, s187 >= 0, s187 <= s186, s19 >= 0, s19 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 11 + z' }-> if(0, s101, 0, 1 + s103 + s105 + (1 + s107 + 0 + r), z', s9) :|: s100 >= 0, s100 <= z, s101 >= 0, s101 <= 2, s102 >= 0, s102 <= z, s103 >= 0, s103 <= s102, s104 >= 0, s104 <= z, s105 >= 0, s105 <= s104, s106 >= 0, s106 <= z, s107 >= 0, s107 <= s106, s9 >= 0, s9 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 11 + z' }-> if(0, s109, 0, 1 + s111 + s113 + (1 + s115 + x + 0), z', s10) :|: s108 >= 0, s108 <= z, s109 >= 0, s109 <= 2, s110 >= 0, s110 <= z, s111 >= 0, s111 <= s110, s112 >= 0, s112 <= z, s113 >= 0, s113 <= s112, s114 >= 0, s114 <= z, s115 >= 0, s115 <= s114, s10 >= 0, s10 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 10 + z' }-> if(0, s117, 0, 1 + s119 + s121 + (1 + s123 + 0 + 0), z', s11) :|: s116 >= 0, s116 <= z, s117 >= 0, s117 <= 2, s118 >= 0, s118 <= z, s119 >= 0, s119 <= s118, s120 >= 0, s120 <= z, s121 >= 0, s121 <= s120, s122 >= 0, s122 <= z, s123 >= 0, s123 <= s122, s11 >= 0, s11 <= z' + z + 1, z >= 0, z' >= 0 listify(z, z') -{ 12 + z' }-> if(0, s45, 0, 1 + s47 + s49 + (1 + s51 + 0 + 0), z', s2) :|: s44 >= 0, s44 <= z, s45 >= 0, s45 <= 2, s46 >= 0, s46 <= z, s47 >= 0, s47 <= s46, s48 >= 0, s48 <= z, s49 >= 0, s49 <= s48, s50 >= 0, s50 <= z, s51 >= 0, s51 <= s50, s2 >= 0, s2 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 11 + z' }-> if(0, s53, 0, 1 + s55 + s57 + (1 + s59 + 0 + 0), z', s3) :|: s52 >= 0, s52 <= z, s53 >= 0, s53 <= 2, s54 >= 0, s54 <= z, s55 >= 0, s55 <= s54, s56 >= 0, s56 <= z, s57 >= 0, s57 <= s56, s58 >= 0, s58 <= z, s59 >= 0, s59 <= s58, s3 >= 0, s3 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 13 + z' }-> if(0, s61, r, 1 + s63 + s65 + (1 + s67 + x'' + r'), z', s4) :|: s60 >= 0, s60 <= z, s61 >= 0, s61 <= 2, s62 >= 0, s62 <= z, s63 >= 0, s63 <= s62, s64 >= 0, s64 <= z, s65 >= 0, s65 <= s64, s66 >= 0, s66 <= z, s67 >= 0, s67 <= s66, s4 >= 0, s4 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 12 + z' }-> if(0, s69, r, 1 + s71 + s73 + (1 + s75 + 0 + r'), z', s5) :|: s68 >= 0, s68 <= z, s69 >= 0, s69 <= 2, s70 >= 0, s70 <= z, s71 >= 0, s71 <= s70, s72 >= 0, s72 <= z, s73 >= 0, s73 <= s72, s74 >= 0, s74 <= z, s75 >= 0, s75 <= s74, s5 >= 0, s5 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 12 + z' }-> if(0, s77, r, 1 + s79 + s81 + (1 + s83 + x' + 0), z', s6) :|: s76 >= 0, s76 <= z, s77 >= 0, s77 <= 2, s78 >= 0, s78 <= z, s79 >= 0, s79 <= s78, s80 >= 0, s80 <= z, s81 >= 0, s81 <= s80, s82 >= 0, s82 <= z, s83 >= 0, s83 <= s82, s6 >= 0, s6 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 11 + z' }-> if(0, s85, r, 1 + s87 + s89 + (1 + s91 + 0 + 0), z', s7) :|: s84 >= 0, s84 <= z, s85 >= 0, s85 <= 2, s86 >= 0, s86 <= z, s87 >= 0, s87 <= s86, s88 >= 0, s88 <= z, s89 >= 0, s89 <= s88, s90 >= 0, s90 <= z, s91 >= 0, s91 <= s90, s7 >= 0, s7 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 12 + z' }-> if(0, s93, 0, 1 + s95 + s97 + (1 + s99 + x' + r), z', s8) :|: s92 >= 0, s92 <= z, s93 >= 0, s93 <= 2, s94 >= 0, s94 <= z, s95 >= 0, s95 <= s94, s96 >= 0, s96 <= z, s97 >= 0, s97 <= s96, s98 >= 0, s98 <= z, s99 >= 0, s99 <= s98, s8 >= 0, s8 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {listify,if}, {toList} Previous analysis results are: isEmpty: runtime: O(1) [1], size: O(1) [2] elem: runtime: O(1) [1], size: O(n^1) [z] append: runtime: O(n^1) [1 + z], size: O(n^1) [1 + z + z'] right: runtime: O(1) [1], size: O(n^1) [z] left: runtime: O(1) [1], size: O(n^1) [z] listify: runtime: ?, size: INF if: runtime: ?, size: INF ---------------------------------------- (55) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: listify after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (56) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 append(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 append(z, z') -{ z }-> 1 + 1 + s :|: s >= 0, s <= z - 2 + z' + 1, z - 2 >= 0, z' >= 0 elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: z >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z = 2, z' >= 0, z'' >= 0, z2 >= 0, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z'', z3) :|: z'' >= 0, z2 >= 0, z' = 2, z = 1, z3 >= 0, z1 >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(z1, z2) :|: z'' >= 0, z2 >= 0, z = 1, z3 >= 0, z' = 1, z1 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: z >= 0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: z >= 0 listify(z, z') -{ 13 + z' }-> if(2, s21, 0, 1 + s23 + s25 + (1 + s27 + 0 + 0), z', s') :|: s20 >= 0, s20 <= z, s21 >= 0, s21 <= 2, s22 >= 0, s22 <= z, s23 >= 0, s23 <= s22, s24 >= 0, s24 <= z, s25 >= 0, s25 <= s24, s26 >= 0, s26 <= z, s27 >= 0, s27 <= s26, s' >= 0, s' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 12 + z' }-> if(2, s29, 0, 1 + s31 + s33 + (1 + s35 + 0 + 0), z', s'') :|: s28 >= 0, s28 <= z, s29 >= 0, s29 <= 2, s30 >= 0, s30 <= z, s31 >= 0, s31 <= s30, s32 >= 0, s32 <= z, s33 >= 0, s33 <= s32, s34 >= 0, s34 <= z, s35 >= 0, s35 <= s34, s'' >= 0, s'' <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 11 + z' }-> if(2, s37, 0, 1 + s39 + s41 + (1 + s43 + 0 + 0), z', s1) :|: s36 >= 0, s36 <= z, s37 >= 0, s37 <= 2, s38 >= 0, s38 <= z, s39 >= 0, s39 <= s38, s40 >= 0, s40 <= z, s41 >= 0, s41 <= s40, s42 >= 0, s42 <= z, s43 >= 0, s43 <= s42, s1 >= 0, s1 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 14 + z' }-> if(1, s125, r', 1 + s127 + s129 + (1 + s131 + x1 + r''), z', s12) :|: s124 >= 0, s124 <= z, s125 >= 0, s125 <= 2, s126 >= 0, s126 <= z, s127 >= 0, s127 <= s126, s128 >= 0, s128 <= z, s129 >= 0, s129 <= s128, s130 >= 0, s130 <= z, s131 >= 0, s131 <= s130, s12 >= 0, s12 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'', r1 >= 0, x1 >= 0, l1 >= 0, z = 1 + l1 + x1 + r1 listify(z, z') -{ 13 + z' }-> if(1, s133, r', 1 + s135 + s137 + (1 + s139 + 0 + r''), z', s13) :|: s132 >= 0, s132 <= z, s133 >= 0, s133 <= 2, s134 >= 0, s134 <= z, s135 >= 0, s135 <= s134, s136 >= 0, s136 <= z, s137 >= 0, s137 <= s136, s138 >= 0, s138 <= z, s139 >= 0, s139 <= s138, s13 >= 0, s13 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 13 + z' }-> if(1, s141, r', 1 + s143 + s145 + (1 + s147 + x'' + 0), z', s14) :|: s140 >= 0, s140 <= z, s141 >= 0, s141 <= 2, s142 >= 0, s142 <= z, s143 >= 0, s143 <= s142, s144 >= 0, s144 <= z, s145 >= 0, s145 <= s144, s146 >= 0, s146 <= z, s147 >= 0, s147 <= s146, s14 >= 0, s14 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 12 + z' }-> if(1, s149, r', 1 + s151 + s153 + (1 + s155 + 0 + 0), z', s15) :|: s148 >= 0, s148 <= z, s149 >= 0, s149 <= 2, s150 >= 0, s150 <= z, s151 >= 0, s151 <= s150, s152 >= 0, s152 <= z, s153 >= 0, s153 <= s152, s154 >= 0, s154 <= z, s155 >= 0, s155 <= s154, s15 >= 0, s15 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 13 + z' }-> if(1, s157, 0, 1 + s159 + s161 + (1 + s163 + x'' + r'), z', s16) :|: s156 >= 0, s156 <= z, s157 >= 0, s157 <= 2, s158 >= 0, s158 <= z, s159 >= 0, s159 <= s158, s160 >= 0, s160 <= z, s161 >= 0, s161 <= s160, s162 >= 0, s162 <= z, s163 >= 0, s163 <= s162, s16 >= 0, s16 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 12 + z' }-> if(1, s165, 0, 1 + s167 + s169 + (1 + s171 + 0 + r'), z', s17) :|: s164 >= 0, s164 <= z, s165 >= 0, s165 <= 2, s166 >= 0, s166 <= z, s167 >= 0, s167 <= s166, s168 >= 0, s168 <= z, s169 >= 0, s169 <= s168, s170 >= 0, s170 <= z, s171 >= 0, s171 <= s170, s17 >= 0, s17 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 12 + z' }-> if(1, s173, 0, 1 + s175 + s177 + (1 + s179 + x' + 0), z', s18) :|: s172 >= 0, s172 <= z, s173 >= 0, s173 <= 2, s174 >= 0, s174 <= z, s175 >= 0, s175 <= s174, s176 >= 0, s176 <= z, s177 >= 0, s177 <= s176, s178 >= 0, s178 <= z, s179 >= 0, s179 <= s178, s18 >= 0, s18 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 11 + z' }-> if(1, s181, 0, 1 + s183 + s185 + (1 + s187 + 0 + 0), z', s19) :|: s180 >= 0, s180 <= z, s181 >= 0, s181 <= 2, s182 >= 0, s182 <= z, s183 >= 0, s183 <= s182, s184 >= 0, s184 <= z, s185 >= 0, s185 <= s184, s186 >= 0, s186 <= z, s187 >= 0, s187 <= s186, s19 >= 0, s19 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 11 + z' }-> if(0, s101, 0, 1 + s103 + s105 + (1 + s107 + 0 + r), z', s9) :|: s100 >= 0, s100 <= z, s101 >= 0, s101 <= 2, s102 >= 0, s102 <= z, s103 >= 0, s103 <= s102, s104 >= 0, s104 <= z, s105 >= 0, s105 <= s104, s106 >= 0, s106 <= z, s107 >= 0, s107 <= s106, s9 >= 0, s9 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 11 + z' }-> if(0, s109, 0, 1 + s111 + s113 + (1 + s115 + x + 0), z', s10) :|: s108 >= 0, s108 <= z, s109 >= 0, s109 <= 2, s110 >= 0, s110 <= z, s111 >= 0, s111 <= s110, s112 >= 0, s112 <= z, s113 >= 0, s113 <= s112, s114 >= 0, s114 <= z, s115 >= 0, s115 <= s114, s10 >= 0, s10 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 10 + z' }-> if(0, s117, 0, 1 + s119 + s121 + (1 + s123 + 0 + 0), z', s11) :|: s116 >= 0, s116 <= z, s117 >= 0, s117 <= 2, s118 >= 0, s118 <= z, s119 >= 0, s119 <= s118, s120 >= 0, s120 <= z, s121 >= 0, s121 <= s120, s122 >= 0, s122 <= z, s123 >= 0, s123 <= s122, s11 >= 0, s11 <= z' + z + 1, z >= 0, z' >= 0 listify(z, z') -{ 12 + z' }-> if(0, s45, 0, 1 + s47 + s49 + (1 + s51 + 0 + 0), z', s2) :|: s44 >= 0, s44 <= z, s45 >= 0, s45 <= 2, s46 >= 0, s46 <= z, s47 >= 0, s47 <= s46, s48 >= 0, s48 <= z, s49 >= 0, s49 <= s48, s50 >= 0, s50 <= z, s51 >= 0, s51 <= s50, s2 >= 0, s2 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 11 + z' }-> if(0, s53, 0, 1 + s55 + s57 + (1 + s59 + 0 + 0), z', s3) :|: s52 >= 0, s52 <= z, s53 >= 0, s53 <= 2, s54 >= 0, s54 <= z, s55 >= 0, s55 <= s54, s56 >= 0, s56 <= z, s57 >= 0, s57 <= s56, s58 >= 0, s58 <= z, s59 >= 0, s59 <= s58, s3 >= 0, s3 <= z' + z + 1, z >= 0, z' >= 0, z = 0 listify(z, z') -{ 13 + z' }-> if(0, s61, r, 1 + s63 + s65 + (1 + s67 + x'' + r'), z', s4) :|: s60 >= 0, s60 <= z, s61 >= 0, s61 <= 2, s62 >= 0, s62 <= z, s63 >= 0, s63 <= s62, s64 >= 0, s64 <= z, s65 >= 0, s65 <= s64, s66 >= 0, s66 <= z, s67 >= 0, s67 <= s66, s4 >= 0, s4 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r', r'' >= 0, x'' >= 0, l'' >= 0, z = 1 + l'' + x'' + r'' listify(z, z') -{ 12 + z' }-> if(0, s69, r, 1 + s71 + s73 + (1 + s75 + 0 + r'), z', s5) :|: s68 >= 0, s68 <= z, s69 >= 0, s69 <= 2, s70 >= 0, s70 <= z, s71 >= 0, s71 <= s70, s72 >= 0, s72 <= z, s73 >= 0, s73 <= s72, s74 >= 0, s74 <= z, s75 >= 0, s75 <= s74, s5 >= 0, s5 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 12 + z' }-> if(0, s77, r, 1 + s79 + s81 + (1 + s83 + x' + 0), z', s6) :|: s76 >= 0, s76 <= z, s77 >= 0, s77 <= 2, s78 >= 0, s78 <= z, s79 >= 0, s79 <= s78, s80 >= 0, s80 <= z, s81 >= 0, s81 <= s80, s82 >= 0, s82 <= z, s83 >= 0, s83 <= s82, s6 >= 0, s6 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' listify(z, z') -{ 11 + z' }-> if(0, s85, r, 1 + s87 + s89 + (1 + s91 + 0 + 0), z', s7) :|: s84 >= 0, s84 <= z, s85 >= 0, s85 <= 2, s86 >= 0, s86 <= z, s87 >= 0, s87 <= s86, s88 >= 0, s88 <= z, s89 >= 0, s89 <= s88, s90 >= 0, s90 <= z, s91 >= 0, s91 <= s90, s7 >= 0, s7 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r listify(z, z') -{ 12 + z' }-> if(0, s93, 0, 1 + s95 + s97 + (1 + s99 + x' + r), z', s8) :|: s92 >= 0, s92 <= z, s93 >= 0, s93 <= 2, s94 >= 0, s94 <= z, s95 >= 0, s95 <= s94, s96 >= 0, s96 <= z, s97 >= 0, s97 <= s96, s98 >= 0, s98 <= z, s99 >= 0, s99 <= s98, s8 >= 0, s8 <= z' + z + 1, z >= 0, z' >= 0, r >= 0, x >= 0, l >= 0, z = 1 + l + x + r, r' >= 0, x' >= 0, l' >= 0, z = 1 + l' + x' + r' right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: z >= 0 toList(z) -{ 1 }-> listify(z, 0) :|: z >= 0 Function symbols to be analyzed: {listify,if}, {toList} Previous analysis results are: isEmpty: runtime: O(1) [1], size: O(1) [2] elem: runtime: O(1) [1], size: O(n^1) [z] append: runtime: O(n^1) [1 + z], size: O(n^1) [1 + z + z'] right: runtime: O(1) [1], size: O(n^1) [z] left: runtime: O(1) [1], size: O(n^1) [z] listify: runtime: INF, size: INF if: runtime: ?, size: INF ---------------------------------------- (57) CompletionProof (UPPER BOUND(ID)) The TRS is a completely defined constructor system, as every type has a constant constructor and the following rules were added: isEmpty(v0) -> null_isEmpty [0] left(v0) -> null_left [0] right(v0) -> null_right [0] elem(v0) -> null_elem [0] append(v0, v1) -> null_append [0] if(v0, v1, v2, v3, v4, v5) -> null_if [0] And the following fresh constants: null_isEmpty, null_left, null_right, null_elem, null_append, null_if ---------------------------------------- (58) Obligation: Runtime Complexity Weighted TRS where all functions are completely defined. The underlying TRS is: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: isEmpty(empty) -> true [1] isEmpty(node(l, x, r)) -> false [1] left(empty) -> empty [1] left(node(l, x, r)) -> l [1] right(empty) -> empty [1] right(node(l, x, r)) -> r [1] elem(node(l, x, r)) -> x [1] append(nil, x) -> cons(x, nil) [1] append(cons(y, ys), x) -> cons(y, append(ys, x)) [1] listify(n, xs) -> if(isEmpty(n), isEmpty(left(n)), right(n), node(left(left(n)), elem(left(n)), node(right(left(n)), elem(n), right(n))), xs, append(xs, n)) [1] if(true, b, n, m, xs, ys) -> xs [1] if(false, false, n, m, xs, ys) -> listify(m, xs) [1] if(false, true, n, m, xs, ys) -> listify(n, ys) [1] toList(n) -> listify(n, nil) [1] isEmpty(v0) -> null_isEmpty [0] left(v0) -> null_left [0] right(v0) -> null_right [0] elem(v0) -> null_elem [0] append(v0, v1) -> null_append [0] if(v0, v1, v2, v3, v4, v5) -> null_if [0] The TRS has the following type information: isEmpty :: empty:node:y:null_left:null_right -> true:false:null_isEmpty empty :: empty:node:y:null_left:null_right true :: true:false:null_isEmpty node :: empty:node:y:null_left:null_right -> null_elem -> empty:node:y:null_left:null_right -> empty:node:y:null_left:null_right false :: true:false:null_isEmpty left :: empty:node:y:null_left:null_right -> empty:node:y:null_left:null_right right :: empty:node:y:null_left:null_right -> empty:node:y:null_left:null_right elem :: empty:node:y:null_left:null_right -> null_elem append :: nil:cons:null_append:null_if -> empty:node:y:null_left:null_right -> nil:cons:null_append:null_if nil :: nil:cons:null_append:null_if cons :: empty:node:y:null_left:null_right -> nil:cons:null_append:null_if -> nil:cons:null_append:null_if y :: empty:node:y:null_left:null_right listify :: empty:node:y:null_left:null_right -> nil:cons:null_append:null_if -> nil:cons:null_append:null_if if :: true:false:null_isEmpty -> true:false:null_isEmpty -> empty:node:y:null_left:null_right -> empty:node:y:null_left:null_right -> nil:cons:null_append:null_if -> nil:cons:null_append:null_if -> nil:cons:null_append:null_if toList :: empty:node:y:null_left:null_right -> nil:cons:null_append:null_if null_isEmpty :: true:false:null_isEmpty null_left :: empty:node:y:null_left:null_right null_right :: empty:node:y:null_left:null_right null_elem :: null_elem null_append :: nil:cons:null_append:null_if null_if :: nil:cons:null_append:null_if Rewrite Strategy: INNERMOST ---------------------------------------- (59) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID)) Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction. The constant constructors are abstracted as follows: empty => 0 true => 2 false => 1 nil => 0 y => 1 null_isEmpty => 0 null_left => 0 null_right => 0 null_elem => 0 null_append => 0 null_if => 0 ---------------------------------------- (60) Obligation: Complexity RNTS consisting of the following rules: append(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 append(z, z') -{ 1 }-> 1 + x + 0 :|: z' = x, x >= 0, z = 0 append(z, z') -{ 1 }-> 1 + 1 + append(ys, x) :|: z' = x, ys >= 0, x >= 0, z = 1 + 1 + ys elem(z) -{ 1 }-> x :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r elem(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 if(z, z', z'', z1, z2, z3) -{ 1 }-> xs :|: z = 2, b >= 0, n >= 0, xs >= 0, z'' = n, z1 = m, ys >= 0, z' = b, z3 = ys, z2 = xs, m >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(m, xs) :|: n >= 0, xs >= 0, z'' = n, z = 1, z1 = m, ys >= 0, z' = 1, z3 = ys, z2 = xs, m >= 0 if(z, z', z'', z1, z2, z3) -{ 1 }-> listify(n, ys) :|: n >= 0, xs >= 0, z'' = n, z' = 2, z = 1, z1 = m, ys >= 0, z3 = ys, z2 = xs, m >= 0 if(z, z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z1 = v3, z3 = v5, v0 >= 0, v4 >= 0, z'' = v2, v1 >= 0, v5 >= 0, z = v0, z' = v1, z2 = v4, v2 >= 0, v3 >= 0 isEmpty(z) -{ 1 }-> 2 :|: z = 0 isEmpty(z) -{ 1 }-> 1 :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r isEmpty(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 left(z) -{ 1 }-> l :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r left(z) -{ 1 }-> 0 :|: z = 0 left(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 listify(z, z') -{ 1 }-> if(isEmpty(n), isEmpty(left(n)), right(n), 1 + left(left(n)) + elem(left(n)) + (1 + right(left(n)) + elem(n) + right(n)), xs, append(xs, n)) :|: n >= 0, xs >= 0, z = n, z' = xs right(z) -{ 1 }-> r :|: r >= 0, x >= 0, l >= 0, z = 1 + l + x + r right(z) -{ 1 }-> 0 :|: z = 0 right(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 toList(z) -{ 1 }-> listify(n, 0) :|: n >= 0, z = n Only complete derivations are relevant for the runtime complexity. ---------------------------------------- (61) CpxTrsToCdtProof (UPPER BOUND(ID)) Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT ---------------------------------------- (62) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) listify(z0, z1) -> if(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)) if(true, z0, z1, z2, z3, z4) -> z3 if(false, false, z0, z1, z2, z3) -> listify(z1, z2) if(false, true, z0, z1, z2, z3) -> listify(z0, z3) toList(z0) -> listify(z0, nil) Tuples: ISEMPTY(empty) -> c ISEMPTY(node(z0, z1, z2)) -> c1 LEFT(empty) -> c2 LEFT(node(z0, z1, z2)) -> c3 RIGHT(empty) -> c4 RIGHT(node(z0, z1, z2)) -> c5 ELEM(node(z0, z1, z2)) -> c6 APPEND(nil, z0) -> c7 APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) LISTIFY(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), ISEMPTY(z0)) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), ISEMPTY(left(z0)), LEFT(z0)) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), RIGHT(z0)) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), LEFT(left(z0)), LEFT(z0)) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), ELEM(left(z0)), LEFT(z0)) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), RIGHT(left(z0)), LEFT(z0)) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), ELEM(z0)) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), RIGHT(z0)) LISTIFY(z0, z1) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), APPEND(z1, z0)) IF(true, z0, z1, z2, z3, z4) -> c18 IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) TOLIST(z0) -> c21(LISTIFY(z0, nil)) S tuples: ISEMPTY(empty) -> c ISEMPTY(node(z0, z1, z2)) -> c1 LEFT(empty) -> c2 LEFT(node(z0, z1, z2)) -> c3 RIGHT(empty) -> c4 RIGHT(node(z0, z1, z2)) -> c5 ELEM(node(z0, z1, z2)) -> c6 APPEND(nil, z0) -> c7 APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) LISTIFY(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), ISEMPTY(z0)) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), ISEMPTY(left(z0)), LEFT(z0)) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), RIGHT(z0)) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), LEFT(left(z0)), LEFT(z0)) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), ELEM(left(z0)), LEFT(z0)) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), RIGHT(left(z0)), LEFT(z0)) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), ELEM(z0)) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), RIGHT(z0)) LISTIFY(z0, z1) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), APPEND(z1, z0)) IF(true, z0, z1, z2, z3, z4) -> c18 IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) TOLIST(z0) -> c21(LISTIFY(z0, nil)) K tuples:none Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2, listify_2, if_6, toList_1 Defined Pair Symbols: ISEMPTY_1, LEFT_1, RIGHT_1, ELEM_1, APPEND_2, LISTIFY_2, IF_6, TOLIST_1 Compound Symbols: c, c1, c2, c3, c4, c5, c6, c7, c8_1, c9_2, c10_3, c11_2, c12_3, c13_3, c14_3, c15_2, c16_2, c17_2, c18, c19_1, c20_1, c21_1 ---------------------------------------- (63) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 1 leading nodes: TOLIST(z0) -> c21(LISTIFY(z0, nil)) Removed 9 trailing nodes: ISEMPTY(node(z0, z1, z2)) -> c1 LEFT(empty) -> c2 APPEND(nil, z0) -> c7 ELEM(node(z0, z1, z2)) -> c6 RIGHT(empty) -> c4 RIGHT(node(z0, z1, z2)) -> c5 ISEMPTY(empty) -> c LEFT(node(z0, z1, z2)) -> c3 IF(true, z0, z1, z2, z3, z4) -> c18 ---------------------------------------- (64) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) listify(z0, z1) -> if(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)) if(true, z0, z1, z2, z3, z4) -> z3 if(false, false, z0, z1, z2, z3) -> listify(z1, z2) if(false, true, z0, z1, z2, z3) -> listify(z0, z3) toList(z0) -> listify(z0, nil) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) LISTIFY(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), ISEMPTY(z0)) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), ISEMPTY(left(z0)), LEFT(z0)) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), RIGHT(z0)) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), LEFT(left(z0)), LEFT(z0)) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), ELEM(left(z0)), LEFT(z0)) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), RIGHT(left(z0)), LEFT(z0)) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), ELEM(z0)) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), RIGHT(z0)) LISTIFY(z0, z1) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), APPEND(z1, z0)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) LISTIFY(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), ISEMPTY(z0)) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), ISEMPTY(left(z0)), LEFT(z0)) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), RIGHT(z0)) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), LEFT(left(z0)), LEFT(z0)) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), ELEM(left(z0)), LEFT(z0)) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), RIGHT(left(z0)), LEFT(z0)) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), ELEM(z0)) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), RIGHT(z0)) LISTIFY(z0, z1) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), APPEND(z1, z0)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) K tuples:none Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2, listify_2, if_6, toList_1 Defined Pair Symbols: APPEND_2, LISTIFY_2, IF_6 Compound Symbols: c8_1, c9_2, c10_3, c11_2, c12_3, c13_3, c14_3, c15_2, c16_2, c17_2, c19_1, c20_1 ---------------------------------------- (65) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 12 trailing tuple parts ---------------------------------------- (66) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) listify(z0, z1) -> if(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)) if(true, z0, z1, z2, z3, z4) -> z3 if(false, false, z0, z1, z2, z3) -> listify(z1, z2) if(false, true, z0, z1, z2, z3) -> listify(z0, z3) toList(z0) -> listify(z0, nil) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) LISTIFY(z0, z1) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), APPEND(z1, z0)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) LISTIFY(z0, z1) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), APPEND(z1, z0)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) K tuples:none Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2, listify_2, if_6, toList_1 Defined Pair Symbols: APPEND_2, LISTIFY_2, IF_6 Compound Symbols: c8_1, c17_2, c19_1, c20_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (67) CdtUsableRulesProof (BOTH BOUNDS(ID, ID)) The following rules are not usable and were removed: listify(z0, z1) -> if(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)) if(true, z0, z1, z2, z3, z4) -> z3 if(false, false, z0, z1, z2, z3) -> listify(z1, z2) if(false, true, z0, z1, z2, z3) -> listify(z0, z3) toList(z0) -> listify(z0, nil) ---------------------------------------- (68) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) LISTIFY(z0, z1) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), APPEND(z1, z0)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) LISTIFY(z0, z1) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), APPEND(z1, z0)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) K tuples:none Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, LISTIFY_2, IF_6 Compound Symbols: c8_1, c17_2, c19_1, c20_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (69) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(z0, z1) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0)), APPEND(z1, z0)) by LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil)), APPEND(nil, z0)) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) ---------------------------------------- (70) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil)), APPEND(nil, z0)) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil)), APPEND(nil, z0)) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) K tuples:none Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (71) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (72) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) K tuples:none Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2, c17_1 ---------------------------------------- (73) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) We considered the (Usable) Rules:none And the Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) The order we found is given by the following interpretation: Polynomial interpretation : POL(APPEND(x_1, x_2)) = 0 POL(IF(x_1, x_2, x_3, x_4, x_5, x_6)) = [1] POL(LISTIFY(x_1, x_2)) = [1] POL(append(x_1, x_2)) = x_1 + x_2 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c12(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c15(x_1)) = x_1 POL(c16(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c19(x_1)) = x_1 POL(c20(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(cons(x_1, x_2)) = 0 POL(elem(x_1)) = [1] POL(empty) = 0 POL(false) = [1] POL(isEmpty(x_1)) = [1] POL(left(x_1)) = [1] POL(nil) = 0 POL(node(x_1, x_2, x_3)) = 0 POL(right(x_1)) = [1] POL(true) = [1] POL(y) = 0 ---------------------------------------- (74) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2, c17_1 ---------------------------------------- (75) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) by LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) ---------------------------------------- (76) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2, c17_1, c9_1 ---------------------------------------- (77) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, x1) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) ---------------------------------------- (78) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2, c17_1, c9_1 ---------------------------------------- (79) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) by LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) ---------------------------------------- (80) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2, c17_1, c9_1, c10_1 ---------------------------------------- (81) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, x1) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) ---------------------------------------- (82) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2, c17_1, c9_1, c10_1 ---------------------------------------- (83) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) by LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) ---------------------------------------- (84) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2, c17_1, c9_1, c10_1, c11_1 ---------------------------------------- (85) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, x1) -> c11(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) ---------------------------------------- (86) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2, c17_1, c9_1, c10_1, c11_1 ---------------------------------------- (87) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) by LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) ---------------------------------------- (88) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c13_1, c14_1, c15_1, c16_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1 ---------------------------------------- (89) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, x1) -> c12(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) ---------------------------------------- (90) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c13_1, c14_1, c15_1, c16_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1 ---------------------------------------- (91) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) by LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) ---------------------------------------- (92) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c14_1, c15_1, c16_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1 ---------------------------------------- (93) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, x1) -> c13(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) ---------------------------------------- (94) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c14_1, c15_1, c16_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1 ---------------------------------------- (95) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) by LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) ---------------------------------------- (96) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c15_1, c16_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1 ---------------------------------------- (97) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, x1) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) ---------------------------------------- (98) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c15_1, c16_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1 ---------------------------------------- (99) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(z0, z1) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) by LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) ---------------------------------------- (100) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c16_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1 ---------------------------------------- (101) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, x1) -> c15(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) ---------------------------------------- (102) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c16_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1 ---------------------------------------- (103) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(z0, z1) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), z1, append(z1, z0))) by LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) ---------------------------------------- (104) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (105) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, x1) -> c16(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) ---------------------------------------- (106) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (107) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(z1, cons(y, z0)) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1))), APPEND(cons(y, z0), z1)) by LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) ---------------------------------------- (108) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (109) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (110) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (111) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) We considered the (Usable) Rules:none And the Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) The order we found is given by the following interpretation: Polynomial interpretation : POL(APPEND(x_1, x_2)) = 0 POL(IF(x_1, x_2, x_3, x_4, x_5, x_6)) = [1] POL(LISTIFY(x_1, x_2)) = [1] POL(append(x_1, x_2)) = x_1 + x_2 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c12(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c15(x_1)) = x_1 POL(c16(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c19(x_1)) = x_1 POL(c20(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(cons(x_1, x_2)) = 0 POL(elem(x_1)) = [1] POL(empty) = 0 POL(false) = [1] POL(isEmpty(x_1)) = [1] POL(left(x_1)) = 0 POL(nil) = 0 POL(node(x_1, x_2, x_3)) = 0 POL(right(x_1)) = [1] POL(true) = [1] POL(y) = 0 ---------------------------------------- (112) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (113) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty)), APPEND(x1, empty)) by LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, cons(y, z0)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, z0), cons(y, append(z0, empty))), APPEND(cons(y, z0), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) ---------------------------------------- (114) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (115) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (116) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (117) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) ---------------------------------------- (118) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (119) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) by LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(x0, x1, x2), cons(y, z0)) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), cons(y, z0), cons(y, append(z0, node(x0, x1, x2)))), APPEND(cons(y, z0), node(x0, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) ---------------------------------------- (120) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (121) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (122) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (123) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) by LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(x0, x1, x2), cons(y, z0)) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), cons(y, z0), cons(y, append(z0, node(x0, x1, x2)))), APPEND(cons(y, z0), node(x0, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) ---------------------------------------- (124) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (125) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (126) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (127) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) by LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, cons(y, z0)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, z0), cons(y, append(z0, empty))), APPEND(cons(y, z0), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) ---------------------------------------- (128) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (129) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (130) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (131) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) ---------------------------------------- (132) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (133) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) by LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(x0, x1, x2), cons(y, z0)) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), cons(y, z0), cons(y, append(z0, node(x0, x1, x2)))), APPEND(cons(y, z0), node(x0, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) ---------------------------------------- (134) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (135) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (136) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (137) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) by LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, cons(y, z0)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, z0), cons(y, append(z0, empty))), APPEND(cons(y, z0), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) ---------------------------------------- (138) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (139) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (140) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (141) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) ---------------------------------------- (142) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (143) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) by LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(x0, x1, x2), cons(y, z0)) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), cons(y, z0), cons(y, append(z0, node(x0, x1, x2)))), APPEND(cons(y, z0), node(x0, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) ---------------------------------------- (144) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (145) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (146) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (147) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) by LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, cons(y, z0)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, z0), cons(y, append(z0, empty))), APPEND(cons(y, z0), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) ---------------------------------------- (148) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (149) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (150) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (151) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) ---------------------------------------- (152) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (153) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) by LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(x0, x1, x2), cons(y, z0)) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), cons(y, z0), cons(y, append(z0, node(x0, x1, x2)))), APPEND(cons(y, z0), node(x0, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) ---------------------------------------- (154) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (155) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (156) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (157) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) by LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, cons(y, z0)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, z0), cons(y, append(z0, empty))), APPEND(cons(y, z0), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) ---------------------------------------- (158) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (159) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (160) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (161) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) ---------------------------------------- (162) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (163) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) by LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(x0, x1, x2), cons(y, z0)) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), cons(y, z0), cons(y, append(z0, node(x0, x1, x2)))), APPEND(cons(y, z0), node(x0, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) ---------------------------------------- (164) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (165) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (166) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (167) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(empty, x1) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty)), APPEND(x1, empty)) by LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, cons(y, z0)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, z0), cons(y, append(z0, empty))), APPEND(cons(y, z0), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) ---------------------------------------- (168) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil)), APPEND(nil, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (169) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (170) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (171) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(APPEND(x0, empty)) ---------------------------------------- (172) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (173) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(node(z0, z1, z2), x1) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) by LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(x0, x1, x2), cons(y, z0)) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), cons(y, z0), cons(y, append(z0, node(x0, x1, x2)))), APPEND(cons(y, z0), node(x0, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) ---------------------------------------- (174) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (175) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (176) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_2, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1 ---------------------------------------- (177) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(node(z0, z1, z2), x1) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2))), APPEND(x1, node(z0, z1, z2))) by LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) LISTIFY(node(x0, x1, x2), cons(y, z0)) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), cons(y, z0), cons(y, append(z0, node(x0, x1, x2)))), APPEND(cons(y, z0), node(x0, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) ---------------------------------------- (178) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil)), APPEND(nil, node(x0, x1, x2))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (179) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (180) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (181) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(z0, nil) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) by LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) ---------------------------------------- (182) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (183) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, nil) -> c17(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) ---------------------------------------- (184) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (185) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(z0, nil) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) by LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) ---------------------------------------- (186) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (187) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, nil) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) ---------------------------------------- (188) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (189) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(z1, cons(y, z0)) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) by LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) ---------------------------------------- (190) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (191) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, cons(y, x1)) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) ---------------------------------------- (192) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (193) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) by LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(empty, cons(y, z0)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, z0), cons(y, append(z0, empty)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) ---------------------------------------- (194) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (195) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) ---------------------------------------- (196) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (197) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) by LISTIFY(node(x0, x1, x2), nil) -> c9(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), cons(y, z0)) -> c9(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), cons(y, z0), cons(y, append(z0, node(x0, x1, x2))))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) ---------------------------------------- (198) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (199) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) by LISTIFY(node(x0, x1, x2), nil) -> c9(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), cons(y, z0)) -> c9(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), cons(y, z0), cons(y, append(z0, node(x0, x1, x2))))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) ---------------------------------------- (200) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (201) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) by LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(empty, cons(y, z0)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, z0), cons(y, append(z0, empty)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) ---------------------------------------- (202) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (203) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) ---------------------------------------- (204) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (205) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) by LISTIFY(node(x0, x1, x2), nil) -> c9(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), cons(y, z0)) -> c9(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), cons(y, z0), cons(y, append(z0, node(x0, x1, x2))))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) ---------------------------------------- (206) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (207) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) by LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(empty, cons(y, z0)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, z0), cons(y, append(z0, empty)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) ---------------------------------------- (208) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (209) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) ---------------------------------------- (210) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (211) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) by LISTIFY(node(x0, x1, x2), nil) -> c9(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), cons(y, z0)) -> c9(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), cons(y, z0), cons(y, append(z0, node(x0, x1, x2))))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) ---------------------------------------- (212) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (213) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) by LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(empty, cons(y, z0)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, z0), cons(y, append(z0, empty)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) ---------------------------------------- (214) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (215) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) ---------------------------------------- (216) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (217) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) by LISTIFY(node(x0, x1, x2), nil) -> c9(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), cons(y, z0)) -> c9(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), cons(y, z0), cons(y, append(z0, node(x0, x1, x2))))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) ---------------------------------------- (218) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (219) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) by LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(empty, cons(y, z0)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, z0), cons(y, append(z0, empty)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) ---------------------------------------- (220) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (221) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, x0) -> c9(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) ---------------------------------------- (222) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (223) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) by LISTIFY(node(x0, x1, x2), nil) -> c9(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), cons(y, z0)) -> c9(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), cons(y, z0), cons(y, append(z0, node(x0, x1, x2))))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) ---------------------------------------- (224) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (225) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) by LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(empty, cons(y, z0)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, z0), cons(y, append(z0, empty)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) ---------------------------------------- (226) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (227) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, x0) -> c9(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) ---------------------------------------- (228) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (229) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(node(z0, z1, z2), x1) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) by LISTIFY(node(x0, x1, x2), nil) -> c9(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), cons(y, z0)) -> c9(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), cons(y, z0), cons(y, append(z0, node(x0, x1, x2))))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) ---------------------------------------- (230) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2 ---------------------------------------- (231) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(node(z0, z1, z2), x1) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) by LISTIFY(node(x0, x1, x2), nil) -> c9(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), cons(y, z0)) -> c9(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), cons(y, z0), cons(y, append(z0, node(x0, x1, x2))))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) ---------------------------------------- (232) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2, c9_1 ---------------------------------------- (233) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(z0, nil) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) by LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) ---------------------------------------- (234) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2, c9_1 ---------------------------------------- (235) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, nil) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) ---------------------------------------- (236) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2, c9_1 ---------------------------------------- (237) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(z1, cons(y, z0)) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) by LISTIFY(z0, cons(y, nil)) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) ---------------------------------------- (238) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2, c9_1 ---------------------------------------- (239) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, cons(y, x1)) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) ---------------------------------------- (240) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2, c9_1 ---------------------------------------- (241) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) by LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(empty, cons(y, z0)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, z0), cons(y, append(z0, empty)))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) ---------------------------------------- (242) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2, c9_1 ---------------------------------------- (243) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LISTIFY(empty, x0) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) ---------------------------------------- (244) Obligation: Complexity Dependency Tuples Problem Rules: isEmpty(empty) -> true isEmpty(node(z0, z1, z2)) -> false left(empty) -> empty left(node(z0, z1, z2)) -> z0 right(empty) -> empty right(node(z0, z1, z2)) -> z2 elem(node(z0, z1, z2)) -> z1 append(nil, z0) -> cons(z0, nil) append(cons(y, z0), z1) -> cons(y, append(z0, z1)) Tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) S tuples: APPEND(cons(y, z0), z1) -> c8(APPEND(z0, z1)) IF(false, false, z0, z1, z2, z3) -> c19(LISTIFY(z1, z2)) IF(false, true, z0, z1, z2, z3) -> c20(LISTIFY(z0, z3)) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c11(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c11(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c12(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c12(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c13(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c13(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c14(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c14(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c15(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c15(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c15(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c15(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, nil) -> c16(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), nil, cons(z0, nil))) LISTIFY(z1, cons(y, z0)) -> c16(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, z0), cons(y, append(z0, z1)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(empty, x1) -> c16(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x1, append(x1, empty))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x1) -> c16(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x1, append(x1, node(z0, z1, z2)))) LISTIFY(z0, cons(y, nil)) -> c17(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil))), APPEND(cons(y, nil), z0)) LISTIFY(z1, cons(y, cons(y, z0))) -> c17(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1)))), APPEND(cons(y, cons(y, z0)), z1)) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, cons(y, x1)) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty))), APPEND(cons(y, x1), empty)) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2)))), APPEND(cons(y, x1), node(z0, z1, z2))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), x2)), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), x1, right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(x0), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(x0), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(x0), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(left(node(x0, x1, x2))), x2, node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, x0) -> c17(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty)), APPEND(x0, empty)) LISTIFY(empty, nil) -> c17(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c17(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2))), APPEND(x3, node(node(z0, z1, z2), x1, x2))) LISTIFY(node(empty, x1, x2), x3) -> c17(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2))), APPEND(x3, node(empty, x1, x2))) LISTIFY(node(z0, z1, z2), x3) -> c17(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2))), APPEND(x3, node(z0, z1, z2))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(isEmpty(node(x0, x1, x2)), isEmpty(x0), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(node(x0, x1, x2), nil) -> c17(IF(false, isEmpty(left(node(x0, x1, x2))), right(node(x0, x1, x2)), node(left(left(node(x0, x1, x2))), elem(left(node(x0, x1, x2))), node(right(left(node(x0, x1, x2))), elem(node(x0, x1, x2)), right(node(x0, x1, x2)))), nil, cons(node(x0, x1, x2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c9(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(empty, elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(z2, elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(empty, elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), z1, node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), isEmpty(left(node(node(z0, z1, z2), x1, x2))), right(node(node(z0, z1, z2), x1, x2)), node(z0, elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), isEmpty(left(node(empty, x1, x2))), right(node(empty, x1, x2)), node(empty, elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), x0, append(x0, empty))) LISTIFY(node(node(z0, z1, z2), x1, x2), x3) -> c9(IF(isEmpty(node(node(z0, z1, z2), x1, x2)), false, right(node(node(z0, z1, z2), x1, x2)), node(left(left(node(node(z0, z1, z2), x1, x2))), elem(left(node(node(z0, z1, z2), x1, x2))), node(right(left(node(node(z0, z1, z2), x1, x2))), elem(node(node(z0, z1, z2), x1, x2)), right(node(node(z0, z1, z2), x1, x2)))), x3, append(x3, node(node(z0, z1, z2), x1, x2)))) LISTIFY(node(empty, x1, x2), x3) -> c9(IF(isEmpty(node(empty, x1, x2)), true, right(node(empty, x1, x2)), node(left(left(node(empty, x1, x2))), elem(left(node(empty, x1, x2))), node(right(left(node(empty, x1, x2))), elem(node(empty, x1, x2)), right(node(empty, x1, x2)))), x3, append(x3, node(empty, x1, x2)))) LISTIFY(node(z0, z1, z2), x3) -> c9(IF(false, isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), x3, append(x3, node(z0, z1, z2)))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(empty, nil) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), nil, cons(empty, nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(node(z0, z1, z2), nil) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), nil, cons(node(z0, z1, z2), nil))) LISTIFY(z0, cons(y, nil)) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), elem(left(z0)), node(right(left(z0)), elem(z0), right(z0))), cons(y, nil), cons(y, cons(z0, nil)))) LISTIFY(z1, cons(y, cons(y, z0))) -> c10(IF(isEmpty(z1), isEmpty(left(z1)), right(z1), node(left(left(z1)), elem(left(z1)), node(right(left(z1)), elem(z1), right(z1))), cons(y, cons(y, z0)), cons(y, cons(y, append(z0, z1))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), z2)), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), z1, right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(z0), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(z0), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(z0), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(left(node(z0, z1, z2))), z2, node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, cons(y, x1)) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), right(empty))), cons(y, x1), cons(y, append(x1, empty)))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(isEmpty(node(z0, z1, z2)), isEmpty(z0), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(node(z0, z1, z2), cons(y, x1)) -> c10(IF(false, isEmpty(left(node(z0, z1, z2))), right(node(z0, z1, z2)), node(left(left(node(z0, z1, z2))), elem(left(node(z0, z1, z2))), node(right(left(node(z0, z1, z2))), elem(node(z0, z1, z2)), right(node(z0, z1, z2)))), cons(y, x1), cons(y, append(x1, node(z0, z1, z2))))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(left(empty)), node(right(empty), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), elem(empty), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) LISTIFY(empty, x0) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), elem(left(empty)), node(right(left(empty)), elem(empty), empty)), x0, append(x0, empty))) K tuples: LISTIFY(empty, x1) -> c17(APPEND(x1, empty)) LISTIFY(x0, cons(y, x1)) -> c17(APPEND(cons(y, x1), x0)) LISTIFY(empty, cons(y, x1)) -> c17(APPEND(cons(y, x1), empty)) Defined Rule Symbols: isEmpty_1, left_1, right_1, elem_1, append_2 Defined Pair Symbols: APPEND_2, IF_6, LISTIFY_2 Compound Symbols: c8_1, c19_1, c20_1, c17_1, c10_1, c11_1, c12_1, c13_1, c14_1, c15_1, c16_1, c17_2, c9_1